-- 12/06/2010 javier07b9@hotmail.com

-- Versión para WINDOWS 32 BITS

-- En el capítulo anterior conseguimos acceder a la memoria de pantalla a traves de los servicios SDL,
-- una vez obtuvimos la dirección de memoria ( almacenada en un atom llamado virtual ) pokeabamos la
-- memoria con valores de 0 a 255 según la intensidad deseada del pixel ya que habiamos seleccionado con
-- la funcion SDL_SetVideoMode() una resolución de 8 bits de color.

-- Ahora nuestro proposito es grabar y cargar algo en memoria ram o de disco.
-- Para ello, utilizaremos las siguientes funciones :

-- fn = open(file,constante)
-- open() abre un fichero con un nombre establecido en el argumento file, el cual sera de tipo sequence
-- ya que en él almacenaremos el nombre del fichero. EL segundo argumento tambien de tipo sequence será
-- una constante que determinará la operación sobre el fichero.
-- Las constantes mas sencillas son "wb" ( write binary ) y "rb" ( read binary ) con las cuales vamos a
-- poder grabar o cargar cualquier fichero de cualquier extension.
-- La funcion open() deposita en una variable de tipo entera un numero de identificacion del archivo.

-- s = get_bytes(fn,size)
-- get_bytes() deposita la cantidad de bytes que la variable size determina del archivo o dispositivo
-- en la variable entera fn.

-- close(fn)
-- Pues eso, cierra el archivo abierto.

-- Ahora crearemos una subrutina o proceso para asi llamar cuantas veces sea necesario, ademas asi podemos
-- ir creando procesos y/o funciones que nos sirvan para futuros programas.
-- Para ello abrimos un proceso llamado graba que creará un archivo cuyo nombre estará en la variable file 
-- de tipo sequence, el archivo será una imagen de los bytes que se encuentren en la dirección de memoria
-- que recoga la variable mem, y la cantidad de bytes a recoger se establece en la variable size.
-- La variable fn de tipo integer recogerá al llamar a open() el número de identificación de archivo.
-- En la variable file de tipo sequence, se determinará el tipo de formato.
-- Si fuera texto de una carta entonces escribiriamos "carta.txt" para que lo pueda leer otros programas.
-- En este caso será una imagen byte a byte de la memoria por lo que le pondré "memoria.mem" cosa que el
-- Windows no reconocerá como formato suyo. El formato no implica reconocimiento en otros programas,
-- podía darle el formato "memoria.bmp" y Windows entenderia que es una imagen Bitmap pero al carecer
-- de cabecera ( unos 54 bytes previos que explican el formato ) seria irreconocible, y lo declararia
-- corrupto.
------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------
include get.e
-- Incluimos el archivo que nos proporciona funciones de entrada y salida.

include machine.e
-- Incluimos funciones para manejar la memoria a bajo nivel.

include SDL_wrap.ew
-- Incluimos las funciones y servicios de la libreria SDL.


atom virtual, surface, dummy
-- Creamos las tres variables necesarias para la inicialización de la pantalla.

constant hx= 640
-- Ancho de la pantalla.

constant hy= 480
-- Alto de la pantalla.

constant bits = 8
-- Bits de color de un pixel.

constant size_video=hy*hx*(bits/8)
-- Bytes totales en la pantalla.

atom t1
-- Variable para el tiempo.

------------------------ SUBRUTINAS graba() y carga() ---------------------------------------------

procedure graba(atom mem, sequence file, integer size) -- Abrimos proceso con tres parámetros.
integer fn                                             -- Recogerá el número de archivo.
sequence s                                             -- Recogerá los bytes de la memoria.
fn=open(file, "wb")                                    -- Abrimos para grabar.
s=peek({mem,size})                                     -- Metemos en la secuencia todos los bytes.
puts(fn,s)                                             -- Grabamos en el archivo todos los bytes.
close(fn)                                              -- Cerramos el archivo.
end procedure                                          -- Fin de proceso.

-- Ahora creamos otro proceso parecido al anterior para cargar un archivo. La diferencia ahora es
-- que vamos a leer, entonces cambiamos en open() por la constante "rb" ( read binary).

procedure carga(atom mem, sequence file, integer size) -- Abrimos proceso con tres parámetros.
integer fn                                             -- Recogerá el número de archivo.
sequence s                                             -- Secuencia para los bytes del archivo.
fn = open(file,"rb")                                   -- Abrimos para leer.
s = get_bytes(fn,size)                                 -- Extraemos los bytes del archivo.
poke (mem,s)                                           -- y los volcanos a la memoria.
close(fn)                                              -- Cerramos el archivo.
end procedure                                          -- Fin de proceso.

----------------------------------------------------------------------------------------------------

dummy = SDL_Init(SDL_INIT_VIDEO) if dummy = -1 then puts(1, "SDL_Init falló en el intento!\n") end if
surface = SDL_SetVideoMode(hx, hy, bits, SDL_DOUBLEBUF+SDL_SWSURFACE+SDL_HWPALETTE+SDL_NOFRAME)
virtual=peek4u(surface+20)
-- Estas tres líneas fueron explicadas en el capítulo 3. Básicamente inicializan la pantalla.

-- Rellenamos la pantalla de colores (números) aleatorios. 
for m=0 to size_video-1 do
poke( virtual+m, rand(255) )
end for

-- Y visualizamos en el monitor la memoria de pantalla.
dummy=SDL_Flip(surface)

t1=time()
-- Capturamos el tiempo.
while time()-t1<1 do
end while
-- Y si el tiempo actual menos el anterior es mayor que 1 segundo entonces finaliza.

-- Grabamos con nuestra subrutina graba() los bytes de la pantalla creando un archivo.
graba(virtual,"pantalla.mem",size_video)
-- Ya tenemos en el disco duro un archivo imagen de la pantalla.

-- Borramos la memoria de pantalla
mem_set(virtual,0,size_video)

-- Y vemos en el monitor que la pantalla ha sido borrada.
dummy=SDL_Flip(surface)

t1=time()
while time()-t1<1 do
end while

-- Ahora cargamos en la memoria de video la imagen para poder verla otra vez.
carga(virtual,"pantalla.mem",size_video)
dummy=SDL_Flip(surface)

t1=time()
while time()-t1<2 do
end while

SDL_Quit()

-- Tal vez alguien pensará que el formato del archivo creado no permite ver la imagen
-- fuera de este programa. Una solución seria colocar antes de los 307200 bytes que
-- conforman la imagen 54 bytes correspondientes a la cabecera del formato BMP.
-- Estos 54 bytes se pueden extraer fácilmente de cualquier imagen en formato BMP
-- que tenga las mismas características que nuestra imagen, esto es 640x480x8, 
-- aprovechando la función carga().

-- Espero algún comentario o duda que tengais. Un saludo y hasta el próximo capítulo.

-- 12/06/2010
-- javier07b9@hotmail.com